package com.pattern.strategy.comparator;

import java.util.Arrays;

/**
 * 自定义实现MyComparable接口  该接口中没有使用泛型
 * 存在的问题： 在MyComparable没有泛型  在MySort中必须强制转换  那么就不通用了
 * 
 * 使用泛型就可以规避这个问题
 *
 * 该形式就是 策略模式
 *
 */
public class Main {
    public static void main(String[] args) {
//        int[] a = {9, 2, 3, 5, 7, 1, 4};
//        Sorter sorter = new Sorter();
//        sorter.sort(a);
//        System.out.println(Arrays.toString(a));

        Cat[] a = {new Cat(3,3), new Cat(5,5), new Cat(1,1)};
        MySorter<Cat> catSorter = new MySorter<>();
        // *** 注意： 此处a和CatComparator 有泛型限制; a数组中对象中元素是Cat, CatComparator中泛型是Cat
        catSorter.sort(a, new CatComparator());
        System.out.println(Arrays.toString(a));

        System.out.println("----------------------------");

        Dog[] d = {new Dog(3), new Dog(5),new Dog(9), new Dog(1),new Dog(7), new Dog(2)};
        MySorter<Dog> dSort = new MySorter<>();
        // *** 注意： 此处d和DogComparator 有泛型限制; d数组中对象中元素是Dog, DogComparator中泛型是Dog
        dSort.sort(d, new DogComparator());
        System.out.println(Arrays.toString(d));

        // 总结： 该策略模式实现了自由比较，并可以自定义比较器
        //          1. 比较Cat类型的数组， 定义Cat的比较器； 使用MySorter中的sort()方法，传入数据以及比较器
        //          2. 比较Dog类型的数组， 定义Dog的比较器； 使用MySorter中的sort()方法，传入数据以及比较器
        //          3. 比较其它类型的数组, 定义其比较器； 使用MySorter中的sort()方法，传入数据以及比较器即可

        System.out.println("-----------lamda表达式-----------------");
        Dog[] l = {new Dog(3), new Dog(5),new Dog(9), new Dog(1),new Dog(7), new Dog(2)};
        MySorter<Dog> lamda = new MySorter<>();
        // *** 注意： 此处d和DogComparator 有泛型限制; d数组中对象中元素是Dog, DogComparator中泛型是Dog
        lamda.sort(l, (o1, o2) -> {
            if(o1.food > o2.food) return -1;
            else if (o1.food < o2.food) return 1;
            return 0;
        });
        System.out.println(Arrays.toString(l));
    }
}
